Magnum One/Magnum One (Mid-American Digital) (Disc Manufacturing).iso/d12/asmbler.arc/CIO.ASM

Assembly Source File | 1988-11-19 | 6KB | 260 lines

ASSUME  CS:C_IO

PUBLIC  C_CREAT,C_OPEN,C_CLOSE,C_READ,C_WRITE,UNLINK,C_BSEEK,RENAME,SEEK_RECORD
PUBLIC  RECORD_ALIGN,C_IOCTL

ENTER   MACRO
        PUSH    BP
        MOV     BP,SP
        ADD     BP,6
        ENDM

EXIT    MACRO
        POP     BP
        ENDM

C_IO    SEGMENT PARA PUBLIC 'CODE'

C_CREAT PROC    FAR
        ; function creat(const n: lstring; a: integer): integer;
        ENTER
        MOV     DX,[BP+2]
        MOV     BX,DX
        ADD     BL,[BX]
        ADC     BH,0
        MOV     BYTE PTR [BX+1],0
        INC     DX
        MOV     CX,[BP]
        MOV     AH,03CH
        INT     21H
        JNC     CR1
        NEG     AX
CR1:    EXIT
        RET     4
C_CREAT ENDP

C_OPEN  PROC    FAR
        ; function open(const n: lstring; a: integer): integer;
        ENTER
        MOV     DX,[BP+2]
        MOV     BX,DX
        ADD     BL,[BX]
        ADC     BH,0
        MOV     BYTE PTR [BX+1],0
        INC     DX
        MOV     AL,[BP]
        MOV     AH,03DH
        INT     21H
        JNC     OP1
        NEG     AX
OP1:    EXIT
        RET     4
C_OPEN  ENDP

C_CLOSE PROC    FAR
        ; function close(fd: integer): integer;
        ENTER
        MOV     BX,[BP]
        MOV     AH,03EH
        INT     21H
        JC      CL1
        XOR     AX,AX
CL1:    EXIT
        RET     2
C_CLOSE ENDP

C_READ  PROC    FAR
        ; function read(fd: integer; buff: adsmem; cnt: integer): integer;
        ENTER
        MOV     BX,[BP+6]
        MOV     CX,[BP]
        PUSH    DS
        LDS     DX,DWORD PTR [BP+2]
        MOV     AH,03FH
        INT     21H
        JNC     RE1
        NEG     AX
RE1:    POP     DS
        EXIT
        RET     8
C_READ  ENDP

C_WRITE PROC    FAR
        ; function write(fd: integer; buff: adsmem; cnt: integer): integer;
        ENTER
        MOV     BX,[BP+6]
        MOV     CX,[BP]
        PUSH    DS
        LDS     DX,DWORD PTR [BP+2]
        MOV     AH,040H
        INT     21H
        JNC     WR1
        NEG     AX
WR1:    POP     DS
        EXIT
        RET     8
C_WRITE ENDP

UNLINK  PROC    FAR
        ; function unlink(const n: lstring): integer;
        ENTER
        MOV     DX,[BP]
        MOV     BX,DX
        ADD     BL,[BX]
        ADC     BH,0
        MOV     BYTE PTR [BX+1],0
        INC     DX
        MOV     AH,041H
        INT     21H
        JC      UN1
        XOR     AX,AX
UN1:    EXIT
        RET     2
UNLINK  ENDP

C_BSEEK PROC    FAR
        ; function bseek(fd: integer; block: integer; kind: integer):  integer;
        ENTER
        MOV     BX,[BP+4]
        MOV     AL,[BP]
        CMP     AL,1
        JL      BS2
        XOR     CX,CX
        XOR     DX,DX
        MOV     AH,042H
        INT     21H
        JC      BS1
        MOV     CX,512
        DIV     CX
        ADD     AX,[BP+2]
        MUL     CX
        MOV     CX,DX
        MOV     DX,AX
        MOV     AL,0
        MOV     AH,042H
        INT     21H
        JNC     BS1
        NEG     AX
        EXIT
        RET     6
BS2:    MOV     AX,512
        MUL     WORD PTR [BP+2]
        MOV     CX,DX
        MOV     DX,AX
        MOV     AH,042H
        INT     21H
        JNC     BS1
        NEG     AX
        EXIT
        RET     6
BS1:    MOV     BX,512
        DIV     BX
        EXIT
        RET     6
C_BSEEK ENDP

SEEK_RECORD     PROC    FAR
        ; function seek_record(fd: integer; recnum,recsiz: integer):  integer;
        ENTER
        MOV     BX,[BP+4]
        MOV     AX,[BP+2]
        MUL     WORD PTR [BP]
        MOV     CX,DX
        MOV     DX,AX
        MOV     AL,0
        MOV     AH,042H
        INT     21H
        JC      RS1
        DIV     WORD PTR [BP]
        TEST    DX,DX
        JNZ     RS1
        EXIT
        RET     6
RS1:    MOV     AX,-6
        EXIT
        RET     6
SEEK_RECORD     ENDP

RENAME  PROC    FAR
        ; function rename(const n1,n2: lstring): integer;
        ENTER
        MOV     DX,[BP+4]
        MOV     BX,DX
        ADD     BL,[BX]
        ADC     BH,0
        MOV     BYTE PTR [BX+1],0
        INC     DX
        MOV     AX,DS
        MOV     ES,AX
        MOV     DI,[BP]
        MOV     BX,DI
        ADD     BL,[BX]
        ADC     BH,0
        MOV     BYTE PTR [BX+1],0
        INC     DI
        MOV     AH,056H
        INT     21H
        JC      RN1
        XOR     AX,AX
RN1:    EXIT
        RET     4
RENAME  ENDP

RECORD_ALIGN    PROC    FAR
        ; function record_align(fd: integer; recsiz: integer):  integer;
        ENTER
        MOV     BX,[BP+2]
        XOR     DX,DX
        XOR     CX,CX
        MOV     AL,1
        MOV     AH,042H
        INT     21H
        JC      RA1
        DIV     WORD PTR [BP]
        TEST    DX,DX
        JZ      RA2
        INC     AX
        PUSH    AX
        MUL     WORD PTR [BP]
        MOV     CX,DX
        MOV     DX,AX
        MOV     AL,0
        MOV     AH,042H
        INT     21H
        POP     AX
        JC      RA1
RA2:    EXIT
        RET     4
RA1:    MOV     AX,-6
        EXIT
        RET     4
RECORD_ALIGN    ENDP

C_IOCTL PROC    FAR
        ; function ioctl(fd: integer; buff: adsmem; size,mode: integer): integer;
        ENTER
        PUSH    DS
        MOV     BX,[BP+8]
        LDS     DX,DWORD PTR [BP+4]
        MOV     CX,[BP+2]
        MOV     AL,[BP]
        CMP     AL,1
        JNE     IO2
        MOV     BX,DX
        MOV     DX,[BX]
IO2:    MOV     AH,044H
        INT     21H
        JNC     IO1
        NEG     AX
IO1:    CMP     BYTE PTR [BP],0
        JNE     IO3
        LDS     BX,DWORD PTR [BP+4]
        MOV     [BX],DX
IO3:    POP     DS
        EXIT
        RET     10
C_IOCTL ENDP

C_IO    ENDS
        END